import { createRouter, createWebHistory } from 'vue-router'
import { constantRoutes } from './constantRoutes'
import { useUserStore } from '@/stores/user'
import { usePermissionStore } from '@/stores/permission'
import NProgress from 'nprogress'
import 'nprogress/nprogress.css'
import Layout from '@/layout/index.vue'
import { asyncRoutes } from './asyncRoutes'
import { Personal } from './asyncRoutes'

// 创建路由实例
const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    ...constantRoutes,
  ]
})

// 白名单，不需要认证的路由
const whiteList = ['/login']

// 保存上次访问的有效路由（不包括登录页和404页面）
function saveLastRoute(route) {
  if (route.name && 
      route.path !== '/login' && 
      route.path !== '/404' && 
      !route.path.includes('workbench')) {
    localStorage.setItem('lastRoute', JSON.stringify({
      name: route.name,
      path: route.path,
      query: route.query,
      params: route.params
    }));
  }
}

// 获取上次的有效路由
function getLastRoute() {
  const lastRouteStr = localStorage.getItem('lastRoute');
  if (lastRouteStr) {
    try {
      return JSON.parse(lastRouteStr);
    } catch (e) {
      return null;
    }
  }
  return null;
}

// 清除上次的路由
function clearLastRoute() {
  localStorage.removeItem('lastRoute');
}

// 路由前置守卫
router.beforeEach(async (to, from, next) => {
  NProgress.start()
  const userStore = useUserStore()
  const permissionStore = usePermissionStore()
  permissionStore.isLoadingRoute = true
  console.log('导航开始:', to.path, '来自:', from.path)

  // 如果是正常导航（不是刷新），且不是去工作台，保存当前路由
  if (from.name && to.name && to.path !== '/dashboard/workbench') {
    saveLastRoute(to);
  }

  const hasToken = userStore.token

  if (hasToken) {
    if (to.path === '/login') {
      // 如果已登录，访问登录页则重定向到首页
      next({ path: '/dashboard/workbench' })
    } else {
      // 检查 pinia store 中是否已有角色信息
      // 注意：如果用户信息可以异步获取，这里的检查可能需要更鲁棒
      const hasUserInfo = Object.keys(userStore.userInfo).length > 0;
      let roles = userStore.roles;

      // 如果没有用户信息，尝试获取
      if (!hasUserInfo) {
        try {
          await userStore.getUserInfo();
          roles = userStore.roles; // 重新获取角色
          console.log('用户信息获取成功，角色:', roles);
        } catch (error) {
          console.error('路由守卫中获取用户信息失败:', error);
          await userStore.resetToken(); // 清除无效 token
          clearLastRoute(); // 清除上次路由
          NProgress.done();
          next(`/login?redirect=${to.path}`);
          return; // 获取失败，中断后续逻辑
        }
      }

      // 检查路由是否已初始化
      if (permissionStore.hasInitRoutes) {
        if (to.matched.length === 0 && to.path !== '/404' && !router.hasRoute(to.name || '')) {
          console.warn(`路由 ${to.path} (或名称 ${to.name}) 不存在于当前路由表中，重定向到工作台`);
          // 避免重定向循环
          if (from.path === '/dashboard/workbench') {
            console.warn('检测到可能从工作台重定向，停止以避免循环');
            NProgress.done();
            next(false); // 停止导航
          } else {
            next({ path: '/dashboard/workbench', replace: true });
          }
        } else {
          next(); // 路由已初始化且目标路由存在 (或为 404 等)，正常放行
        }
      } else {
        // 路由未初始化，生成并添加路由
        try {
          const accessRoutes = await permissionStore.generateRoutes();

          if (accessRoutes && accessRoutes.length > 0) {
            console.log('开始动态添加路由...');
            accessRoutes.forEach(route => {
              // 检查是否已存在同名路由，避免重复添加警告
              if (!router.hasRoute(route.name)) {
                console.log(`添加路由: ${route.name}, path: ${route.path}`);
                router.addRoute(route);
              } else {
                console.warn(`路由 '${route.name}' 已存在，跳过添加。`);
              }
            });
            console.log('动态路由添加完成。');
            permissionStore.setHasInitRoutes(true);

            // 优化方案：尝试直接导航到目标路由，减少闪烁
            const lastRoute = getLastRoute();
            
            // 如果是刷新操作且有保存的路由
            if (lastRoute && !from.name) {
              try {
                // 检查是否已添加目标路由
                const routeExists = router.hasRoute(lastRoute.name);
                if (routeExists) {
                  // 如果路由已添加成功，直接导航到目标路由
                  console.log('直接导航到保存的路由:', lastRoute.path);
                  next({
                    name: lastRoute.name,
                    path: lastRoute.path,
                    query: lastRoute.query || {},
                    params: lastRoute.params || {},
                    replace: true
                  });
                } else {
                  // 如果路由未添加成功，先导航到首页，避免404
                  console.log('目标路由不存在，导航到工作台');
                  next({ path: '/dashboard/workbench', replace: true });
                }
              } catch (e) {
                console.error('导航到保存的路由失败:', e);
                next({ path: '/dashboard/workbench', replace: true });
              }
            } else {
              // 对于正常导航或没有保存路由的情况，去首页
              next({ path: '/dashboard/workbench', replace: true });
            }
          } else {
            await userStore.resetToken(); // 可能权限有问题，清除 token
            clearLastRoute(); // 清除上次路由
            NProgress.done();
            next('/login'); // 或者 next({ path: '/dashboard/workbench', replace: true }); 如果希望留在系统内
          }
        } catch (error) {
          console.error('生成或添加动态路由时出错:', error);
          await userStore.resetToken(); // 清除 token
          clearLastRoute(); // 清除上次路由
          NProgress.done();
          next(`/login?redirect=${to.path}`); // 重定向到登录页
        }
      }
    }
  } else {
    if (whiteList.includes(to.path)) {
      next();
    } else {
      clearLastRoute(); // 清除上次路由
      NProgress.done();
      // 之前的逻辑：如果目标是 /404，则登录后去首页
      if (to.path === '/404') {
        next({ path: '/login' });
      } else {
        next({ path: '/login', query: { redirect: to.path } });
      }
    }
  }
});

// 路由后置守卫，确保 NProgress 和加载状态总是结束
router.afterEach(() => {
  const permissionStore = usePermissionStore()
  permissionStore.isLoadingRoute = false
  NProgress.done()
})

// 导出路由实例
export default router
